/**
 * 从对象数组中获取指定 key 值为指定值的对象
 * @param arr - 对象数组
 * @param key - 键名
 * @param value - 键对应的值
 * @param findAll - 是否返回所有匹配的对象，true 返回所有，false 返回第一个匹配项
 * @returns 符合条件的对象或对象数组
 */
export function getObjectByKeyValue<T extends Record<string, any>>(
    arr: T[],
    key: keyof T,
    value: any,
    findAll: boolean = false
): T | T[] | undefined {
    if (findAll) {
        return arr.filter(item => item[key] === value);
    } else {
        return arr.find(item => item[key] === value);
    }
}

/**
 * 将 '-' 分割的字符串转换为首字母大写的驼峰命名
 * @param str - 输入的用 '-' 分割的字符串
 * @returns 转换后的首字母大写的驼峰命名字符串
 */
export function toPascalCase(str: string): string {
    return str
        .split('-')                // 以 '-' 分割字符串
        .map(word => word.charAt(0).toUpperCase() + word.slice(1))  // 首字母大写
        .join('');                 // 拼接成驼峰命名
}


/**
 * 将驼峰命名转换为烤肉串命名
 * @param str - 驼峰命名的字符串
 * @returns 烤肉串命名的字符串
 */
export function camelToKebab(str: string): string {
    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
}

/**
 * 将烤肉串命名转换为驼峰命名
 * @param str - 烤肉串命名的字符串
 * @returns 驼峰命名的字符串
 */
export function kebabToCamel(str: string): string {
    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
}

/**
 * 将字符串转换为指定格式
 * @param input
 * @param targetFormat
 */
export function convertString(input: string, targetFormat: 'camel' | 'kebab'): string {
    if(!input) return input;
    if (targetFormat === 'camel') {
        // 先特殊处理，将 v-model 转回 modelValue
        input = input.replace(/v-model/g, 'modelValue');
        // 检查是否已经是驼峰格式
        if (!input.includes('-')) {
            return input;
        }
        // 将 kebab-case 转换为 camelCase
        return input.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
    } else if (targetFormat === 'kebab') {
        // 先特殊处理，将 modelValue 转换为 v-model
        input = input.replace(/modelValue/g, 'v-model');

        // 检查是否已经是 kebab-case 格式
        if (!/[A-Z]/.test(input)) {
            return input;
        }
        // 将 camelCase 转换为 kebab-case
        return input.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
    }
    return input;
}

/**
 * 转换数据对象的键
 * @param data - 待转换的对象
 * @param toKebab - 是否转换为烤肉串命名，true为转换为烤肉串命名，false为驼峰命名
 * @returns 转换后的对象
 */
export function transformKeys(data: Record<string, any>, toKebab: boolean): Record<string, any> {
    const transformFn = toKebab ? camelToKebab : kebabToCamel;

    return Object.keys(data).reduce((acc, key) => {
        const transformedKey = transformFn(key);
        acc[transformedKey] = data[key];
        return acc;
    }, {} as Record<string, any>);
}

/**
 * 在驼峰命名和烤肉串命名之间切换
 * @param str - 输入的字符串
 * @param toKebab - 是否转换为烤肉串命名，true为转换为烤肉串命名，false为驼峰命名
 * @returns 转换后的字符串
 */
export function transformString(str: string, toKebab: boolean): string {
    if (str === 'v-model') {
        return 'modelValue'
    } else {
        return toKebab ? camelToKebab(str) : kebabToCamel(str);
    }
}



/**
 * 批量替换文本中的颜色值
 * @param text - 需要替换的文本
 * @param colorMap - 颜色映射表，键为旧颜色（HEX或RGB格式），值为替换的新颜色
 * @returns 替换后的文本
 */
export function replaceColors(
    text: string,
    colorMap: Record<string, string>
): string {
    // 参数类型校验
    if (typeof text !== 'string') {
        throw new TypeError('参数 text 必须是字符串类型');
    }
    if (typeof colorMap !== 'object' || Array.isArray(colorMap)) {
        throw new TypeError('参数 colorMap 必须是对象类型');
    }

    // 构建正则表达式，支持 HEX 和 RGB 格式
    const pattern = new RegExp(
        Object.keys(colorMap).map(escapeRegExp).join('|'),
        'gi'
    );

    // 使用正则替换匹配的颜色
    return text.replace(pattern, (matchedColor) =>
        colorMap[matchedColor.toLowerCase()] || matchedColor
    );
}

/**
 * 转义正则表达式中的特殊字符
 * @param str - 需要转义的字符串
 * @returns 转义后的字符串
 */
export function escapeRegExp(str: string): string {
    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

